DLP Release Notes (version 1r18N)


Updates


Contents


top

Download

Local cs.vu.nl info: note that there is a pre-installed Solaris version of DLP in directory /home/dejavu/dlp. See the DLP@cs.vu.nl page for more information.

DLP/JVM is currently a pre-compiled distribution : dlp1r18N.tar.gz. The system is actively used on the following platforms: Cygwin, Linux, Solaris, Windows NT, and Windows 2000.

Overview of the directory structure of the distribution :
	dlp1r18N/
		bin/
			dlp		## command line execution
			dlpc		## compiler shell script (Cygwin / Linux / Solaris)
		classes/
			dlpsys.jar	## pre-compiled libraries and run-time system
		examples/
			README.txt
			....
			*.pl		## DLP program examples
			makefile	## for the compilation of the DLP examples
			setvars.j140	## environment variable settings (Linux / Solaris)
			setvars.cygw	## environment variable settings (Cygwin)
			....
		lib/
			execomp.qlf	## compiler front-end / back-end

A number of files that are also included in the distribution are listed here separately (allowing for the incremental update of your DLP system) : In case you would like to update dlpsys.jar or execomp.qlf, update both files. The same for the dlpc or setvars.* files : update dlpc as well as the setvars.* file. Changes will be documented in the Updates section of this readme file.

A full update (as well as an incremental update of dlpsys.jar and / or execomp.qlf) requires currently the re-compilation of your DLP program source files.
top

Installation


top

Compilation

When compiling a DLP program "prog.pl" :
 dlpc prog.pl 
in directory "/home/user/project/qwerty", the generated JVM class files are written to the corresponding "/home/user/project/qwerty/classes" subdirectory. As mentioned in the setvars files, this "classes" subdirectory should also be included in your CLASSPATH or JIKESPATH environment variable.
top

Execution


top

Summary of Built-ins

If you're familiar with a logic programming language like Prolog, you will understand what the predicates mentioned below mean and how they should be used. If not ... you will find some introductory information here.

Arithmetic comparison

Arithmetic evaluation

Atomic term processing

Character input/output

Logic and control

Stream selection and control

Term comparison

Term creation and decomposition

Term input/output

Term input from constant terms

Term output to constant terms

Term unification

Type testing

List Processing

Miscellaneous


top

TCP / IP Networking


top

EAI Node::Field like Storage-Retrieval / Synchronization Predicates

DLP can be used to develop multi-threaded stand-alone client / server systems as well as multi-threaded programs running in the context of browsers, VRML / EAI frameworks, or other special purpose environments that support JVM based execution. When developing distributed VRML / EAI Web based DLP systems it's often convenient to provide the server part of the system with similar capabilities as available in the VRML/EAI embedded clients of the system in order to maintain the (distributed) state of particular nodes. This allows for a similar modeling approach of several storage and retrieval aspects in both the client and server parts.
The EAI-like NodeName :: FieldName storage and retrieval predicates (see below) provide such a functionality. Although they are primarily intended for stand-alone servers, i.e. servers not embedded in a VRML / EAI framework, they can also be used for other purposes. Typically, such a server will handle multiple independently running client threads, therefore the storage and retrieval predicates are extended to deal with event driven, i.e. (internally) wait / notify based, processing.

Get / Set Field Predicates :

The NodeName and FieldName predicate arguments are atoms. Predicate set_field sets the associated value of the specified FieldName or NodeName and FieldName combination to the term as mentioned in the Term argument. Predicate get_field returns the stored Term value or returns the atom undefined when not yet defined by a set_field predicate. The get_field predicate is non-blocking; it always returns immediately.
Predicate get_field_event blocks until a set_field operation sets the corresponding value, after which it returns that value and "resets" the field. This blocking and reset behavior can be independently selected by the get_field_block (no reset) or get_field_reset (no blocking) predicates respectively.
An implicit (get_field_event) or explicit (get_field_reset) field reset doesn't set the field value to undefined, but only flags that the value has been retrieved. This allows non-blocking predicates to get the latest field value.
Summary: get_field and get_field_reset are non-blocking : they allow for polling a particular field value. Predicates get_field_block and get_field_event always block until a new field value has been defined by the set_field predicate. Blocking and unblocking are (internally) wait / notify driven.

Get / Set Queue Predicates :

Queue predicates provide a flexible way to construct special purpose asynchronous interaction patterns or protocols between active objects. All queue primitives are safe in multi-threaded execution contexts (atomic queue update). NodeName and QueueName predicate arguments are atoms. Predicate new_queue creates a unique queue. The maximum number of queue elements is defined by MaxSize. When a queue isn't defined yet by new_queue upon the first invocation of a set_queue or get_queue predicate, a queue descriptor will automatically be created with a default maximum size of 100.
Predicate set_queue appends a new Term to the queue. If the queue contains MaxSize elements this operation will block until a get_queue operation removes an element from the queue. Predicate get_queue removes the first element from the queue and unifies this element with Term. In case the queue is empty, this operation will block until a set_queue operation adds an element to the queue.

Conditional Queue Lookup Predicates :

Get / Set Array Predicates :

Fine-grained Multi-threaded Synchronization

Program Examples / Sources


top

DLP Regular Expression Library Predicates



top

Atom / String Predicates

In logic programming languages, atoms are typically used for the representation of symbolic constants. Usually they have a relatively modest size and they can be used efficiently in many contexts. However, the implementation of atoms is optimized for unification; all identical atoms have a unique reference, which reduces the atom related string comparison operations to a single object reference comparison. Although atoms may be used for several text-like manipulation and inspection issues, a number of applications require sometimes a representation that is more appropriate for manipulating text in general.
top

DLP / JavaScript Interface


top

DLP / XML : Extensible Markup Language Predicates


top

Multi-threaded Objects (Syntax Summary)


top

DLP Foreign Language Interface

FLI Program Example

Term Dereferencing

Term Creation

Term Type Tests

Term Type Casts

Term Value Retrieval


top

Vectors / Quaternions (vectorlib)


top

DLP / EAI: VRML External Authoring Interface Library (Summary)


top